package manong.beans;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;

public class CourseTable implements Cloneable, Serializable {

    private Integer id;
    private Integer arrId;
    private Integer courseId;
    private Integer classId;
    private Integer roomId;
    private Integer techerId;
    private Integer semeId;
    private String semeName;
    private Integer timeId;
    private String timeName;
    private String courseName;
    private String className;
    private String roomName;
    private String techerName;
    private Integer statu;
    private Integer temporary;
    private String mark;
    private static final long serialVersionUID = 1L;

    public CourseTable(Integer id, Integer arrId, Integer courseId, Integer classId, Integer roomId, Integer techerId, Integer semeId, String semeName, Integer timeId, String timeName, String courseName, String className, String roomName, String techerName, Integer statu, Integer temporary, String mark) {
        this.id = id;
        this.arrId = arrId;
        this.courseId = courseId;
        this.classId = classId;
        this.roomId = roomId;
        this.techerId = techerId;
        this.semeId = semeId;
        this.semeName = semeName;
        this.timeId = timeId;
        this.timeName = timeName;
        this.courseName = courseName;
        this.className = className;
        this.roomName = roomName;
        this.techerName = techerName;
        this.statu = statu;
        this.temporary = temporary;
        this.mark = mark;
    }


    public CourseTable() {
        super();
    }
//构造方法,用来创建CourseTable对象实例。super()调用了父类的构造方法。
  
    public Integer getId() {
        return id;
    }

    public CourseTable withId(Integer id) {
        this.setId(id);
        return this;
    }
//接受一个整数类型的参数 id，并将其设置为当前对象的 id 属性，然后返回当前对象实例。这种设计模式通常用于实现一种叫做“流式接口（fluent interface）”的编程风格。

    
    /*
    
    
    
    
    
    "流式接口"（Fluent Interface）是一种编程风格，旨在使代码更具可读性和可维护性。它的主要目的是提高代码的可读性，
    以便更自然地表达一系列操作，并且通常用于构建复杂的方法调用链。下面是一些使用流式接口编程风格的好处：

1 自然语言感觉：流式接口允许代码以一种自然语言的方式表达，使代码更容易理解。这使得代码更易于阅读和维护，因为它更接近人类语言的表达方式。

2 方法链式调用：通过链式调用，可以在一行代码中执行多个操作，而无需创建临时变量或多次调用方法。这可以减少代码行数，提高可读性，并降低出错的可能性。

3 链式配置：流式接口通常用于配置对象的属性或参数。通过连续调用设置方法，可以按照一种清晰的方式配置对象，而无需编写大量的重复代码。

4 减少中间状态：使用流式接口，可以避免创建大量中间变量，因为每个方法都返回自身的实例。这使得代码更简洁，减少了可能引入错误的机会。

5 可以提高可维护性：通过使代码更清晰和自然，流式接口可以提高代码的可维护性。当需要修改代码时，开发人员更容易理解代码的作用和结构，因此更容易进行维护和改进。

6 语义清晰：流式接口可以提供更具语义的方法名，使代码更易于理解。例如，可以使用withId()而不是简单的setId()，这更清晰地表达了方法的目的。

流式接口最常见的用例之一是构建配置对象或建立查询。例如，数据库查询构建器、配置对象初始化等情况下都可以使用流式接口，以提高代码的可读性和表达能力。
总之，流式接口是一种编程风格，旨在提高代码的可读性和表达能力，使代码更清晰、更自然，并降低错误的可能性，从而提高代码的可维护性。
    
    
    
    
    
    
    */
    
    
    
    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getArrId() {
        return arrId;
    }

    public CourseTable withArrId(Integer arrId) {
        this.setArrId(arrId);
        return this;
    }

    public void setArrId(Integer arrId) {
        this.arrId = arrId;
    }

 
    public Integer getCourseId() {
        return courseId;
    }

    public CourseTable withCourseId(Integer courseId) {
        this.setCourseId(courseId);
        return this;
    }

    public void setCourseId(Integer courseId) {
        this.courseId = courseId;
    }

    public Integer getClassId() {
        return classId;
    }

    public CourseTable withClassId(Integer classId) {
        this.setClassId(classId);
        return this;
    }


    public void setClassId(Integer classId) {
        this.classId = classId;
    }

    public Integer getRoomId() {
        return roomId;
    }

    public CourseTable withRoomId(Integer roomId) {
        this.setRoomId(roomId);
        return this;
    }

    public void setRoomId(Integer roomId) {
        this.roomId = roomId;
    }

    public Integer getTecherId() {
        return techerId;
    }

    public CourseTable withTecherId(Integer techerId) {
        this.setTecherId(techerId);
        return this;
    }

    public void setTecherId(Integer techerId) {
        this.techerId = techerId;
    }

    public Integer getSemeId() {
        return semeId;
    }

    public CourseTable withSemeId(Integer semeId) {
        this.setSemeId(semeId);
        return this;
    }

    public void setSemeId(Integer semeId) {
        this.semeId = semeId;
    }

    public String getSemeName() {
        return semeName;
    }

 
    public CourseTable withSemeName(String semeName) {
        this.setSemeName(semeName);
        return this;
    }

    public void setSemeName(String semeName) {
        this.semeName = semeName;
    }


    public Integer getTimeId() {
        return timeId;
    }

    public CourseTable withTimeId(Integer timeId) {
        this.setTimeId(timeId);
        return this;
    }

    public void setTimeId(Integer timeId) {
        this.timeId = timeId;
    }

    public String getTimeName() {
        return timeName;
    }

    public CourseTable withTimeName(String timeName) {
        this.setTimeName(timeName);
        return this;
    }
//更加流畅地创建和配置CourseTable对象，使代码更具可读性
 
    public void setTimeName(String timeName) {
        this.timeName = timeName;
    }

    public String getCourseName() {
        return courseName;
    }


    public CourseTable withCourseName(String courseName) {
        this.setCourseName(courseName);
        return this;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }


    public String getClassName() {
        return className;
    }

    public CourseTable withClassName(String className) {
        this.setClassName(className);
        return this;
    }


    public void setClassName(String className) {
        this.className = className;
    }

  
    public String getRoomName() {
        return roomName;
    }


    public CourseTable withRoomName(String roomName) {
        this.setRoomName(roomName);
        return this;
    }

    public void setRoomName(String roomName) {
        this.roomName = roomName;
    }

    public String getTecherName() {
        return techerName;
    }

    public CourseTable withTecherName(String techerName) {
        this.setTecherName(techerName);
        return this;
    }

    public void setTecherName(String techerName) {
        this.techerName = techerName;
    }


    public Integer getStatu() {
        return statu;
    }

    public CourseTable withStatu(Integer statu) {
        this.setStatu(statu);
        return this;
    }
  //  它用于设置CourseTable对象的状态（statu）属性，并返回对象本身，以便进行链式调用。  ---》一次调用多个属性

    public void setStatu(Integer statu) {
        this.statu = statu;
    }

    public Integer getTemporary() {
        return temporary;
    }

    public CourseTable withTemporary(Integer temporary) {
        this.setTemporary(temporary);
        return this;
    }

    public void setTemporary(Integer temporary) {
        this.temporary = temporary;
    }

    public String getMark() {
        return mark;
    }

    public CourseTable withMark(String mark) {
        this.setMark(mark);
        return this;
    }

    public void setMark(String mark) {
        this.mark = mark;
    }

    @Override
    public boolean equals(Object that) {
        if (this == that) {
            return true;
        }
        if (that == null) {
            return false;
        }
        if (getClass() != that.getClass()) {
            return false;
        }
        CourseTable other = (CourseTable) that;
        return (this.getId() == null ? other.getId() == null : this.getId().equals(other.getId()))
            && (this.getArrId() == null ? other.getArrId() == null : this.getArrId().equals(other.getArrId()))
            && (this.getCourseId() == null ? other.getCourseId() == null : this.getCourseId().equals(other.getCourseId()))
            && (this.getClassId() == null ? other.getClassId() == null : this.getClassId().equals(other.getClassId()))
            && (this.getRoomId() == null ? other.getRoomId() == null : this.getRoomId().equals(other.getRoomId()))
            && (this.getTecherId() == null ? other.getTecherId() == null : this.getTecherId().equals(other.getTecherId()))
            && (this.getSemeId() == null ? other.getSemeId() == null : this.getSemeId().equals(other.getSemeId()))
            && (this.getSemeName() == null ? other.getSemeName() == null : this.getSemeName().equals(other.getSemeName()))
            && (this.getTimeId() == null ? other.getTimeId() == null : this.getTimeId().equals(other.getTimeId()))
            && (this.getTimeName() == null ? other.getTimeName() == null : this.getTimeName().equals(other.getTimeName()))
            && (this.getCourseName() == null ? other.getCourseName() == null : this.getCourseName().equals(other.getCourseName()))
            && (this.getClassName() == null ? other.getClassName() == null : this.getClassName().equals(other.getClassName()))
            && (this.getRoomName() == null ? other.getRoomName() == null : this.getRoomName().equals(other.getRoomName()))
            && (this.getTecherName() == null ? other.getTecherName() == null : this.getTecherName().equals(other.getTecherName()))
            && (this.getStatu() == null ? other.getStatu() == null : this.getStatu().equals(other.getStatu()))
            && (this.getTemporary() == null ? other.getTemporary() == null : this.getTemporary().equals(other.getTemporary()))
            && (this.getMark() == null ? other.getMark() == null : this.getMark().equals(other.getMark()));
    }

 
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((getId() == null) ? 0 : getId().hashCode());
        result = prime * result + ((getArrId() == null) ? 0 : getArrId().hashCode());
        result = prime * result + ((getCourseId() == null) ? 0 : getCourseId().hashCode());
        result = prime * result + ((getClassId() == null) ? 0 : getClassId().hashCode());
        result = prime * result + ((getRoomId() == null) ? 0 : getRoomId().hashCode());
        result = prime * result + ((getTecherId() == null) ? 0 : getTecherId().hashCode());
        result = prime * result + ((getSemeId() == null) ? 0 : getSemeId().hashCode());
        result = prime * result + ((getSemeName() == null) ? 0 : getSemeName().hashCode());
        result = prime * result + ((getTimeId() == null) ? 0 : getTimeId().hashCode());
        result = prime * result + ((getTimeName() == null) ? 0 : getTimeName().hashCode());
        result = prime * result + ((getCourseName() == null) ? 0 : getCourseName().hashCode());
        result = prime * result + ((getClassName() == null) ? 0 : getClassName().hashCode());
        result = prime * result + ((getRoomName() == null) ? 0 : getRoomName().hashCode());
        result = prime * result + ((getTecherName() == null) ? 0 : getTecherName().hashCode());
        result = prime * result + ((getStatu() == null) ? 0 : getStatu().hashCode());
        result = prime * result + ((getTemporary() == null) ? 0 : getTemporary().hashCode());
        result = prime * result + ((getMark() == null) ? 0 : getMark().hashCode());
        return result;
    }
    //判断两个CourseTable对象是否在所有属性上都相等

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(getClass().getSimpleName());
        sb.append(" [");
        sb.append("Hash = ").append(hashCode());
        sb.append(", id=").append(id);
        sb.append(", arrId=").append(arrId);
        sb.append(", courseId=").append(courseId);
        sb.append(", classId=").append(classId);
        sb.append(", roomId=").append(roomId);
        sb.append(", techerId=").append(techerId);
        sb.append(", semeId=").append(semeId);
        sb.append(", semeName=").append(semeName);
        sb.append(", timeId=").append(timeId);
        sb.append(", timeName=").append(timeName);
        sb.append(", courseName=").append(courseName);
        sb.append(", className=").append(className);
        sb.append(", roomName=").append(roomName);
        sb.append(", techerName=").append(techerName);
        sb.append(", statu=").append(statu);
        sb.append(", temporary=").append(temporary);
        sb.append(", mark=").append(mark);
        sb.append("]");
        return sb.toString();
    }
//用于将对象的信息转换为字符串，用于调试和日志记录等目的。    ----》以便它们能够以有意义的方式被转换为字符串
    @Override
    public CourseTable clone() throws CloneNotSupportedException {
        return (CourseTable) super.clone();
    }

    public enum Column {
        id("id", "id", "INTEGER", false),
        arrId("arr_id", "arrId", "INTEGER", false),
        courseId("course_id", "courseId", "INTEGER", false),
        classId("class_id", "classId", "INTEGER", false),
        roomId("room_id", "roomId", "INTEGER", false),
        techerId("techer_id", "techerId", "INTEGER", false),
        semeId("seme_id", "semeId", "INTEGER", false),
        semeName("seme_name", "semeName", "VARCHAR", false),
        timeId("time_id", "timeId", "INTEGER", false),
        timeName("time_name", "timeName", "VARCHAR", false),
        courseName("course_name", "courseName", "VARCHAR", false),
        className("class_name", "className", "VARCHAR", false),
        roomName("room_name", "roomName", "VARCHAR", false),
        techerName("techer_name", "techerName", "VARCHAR", false),
        statu("statu", "statu", "INTEGER", false),
        temporary("temporary", "temporary", "INTEGER", true),
        mark("mark", "mark", "VARCHAR", false);

    	//为了独立地操作副本对象，而不影响原始对象。--》防止修改原始对象
    	
    	
    	
    	
    	
    	
    	
    	/*
    	
 用于处理数据库表列的元数据的实用类。它提供了一些方法来获取列名、Java属性名、JDBC数据类型以及用于排序的字符串表示形式。
 可能是用于支持数据库操作的ORM（对象-关系映射）框架中的一部分。   	
    	*/
    	
    	
    	
    //以便在与数据库交互的过程中，能够更容易地引用列名、属性名和数据类型，避免硬编码，减少错误。这在许多ORM（对象-关系映射）框架和数据库操作中都是常见的做法。
        private static final String BEGINNING_DELIMITER = "`";
//是私有的字符串常量，用于指定列名的起始和结束分隔符。
        private static final String ENDING_DELIMITER = "`";

        private final String column;
        //私有字段，表示数据库表的列名。
        
        
        
        private final boolean isColumnNameDelimited;
//私有布尔字段，表示列名是否包含在分隔符内。
        
        

        private final String javaProperty;
//私有字段，表示与数据库列关联的Java属性名。
        
        
        private final String jdbcType;
//私有字段，表示与数据库列关联的JDBC数据类型。
        
        
        public String value() {
            return this.column;
        }

        public String getValue() {
            return this.column;
        }

        public String getJavaProperty() {
            return this.javaProperty;
        }

        public String getJdbcType() {
            return this.jdbcType;
        }

        Column(String column, String javaProperty, String jdbcType, boolean isColumnNameDelimited) {
            this.column = column;
            this.javaProperty = javaProperty;
            this.jdbcType = jdbcType;
            this.isColumnNameDelimited = isColumnNameDelimited;
        }
//类的构造函数，用于初始化column、javaProperty、jdbcType和isColumnNameDelimited字段。
        
        
        
        public String desc() {
            return this.getEscapedColumnName() + " DESC";
        }
//返回一个字符串，表示列名加上" DESC" 或 " ASC"，用于排序查询结果。
        public String asc() {
            return this.getEscapedColumnName() + " ASC";
        }
        
        
        
        
        
        
        
        
        
//帮助生成SQL查询和操作数据库表列的相关属性
        public static Column[] excludes(Column ... excludes) {
            ArrayList<Column> columns = new ArrayList<>(Arrays.asList(Column.values()));
            if (excludes != null && excludes.length > 0) {
                columns.removeAll(new ArrayList<>(Arrays.asList(excludes)));
            }
            return columns.toArray(new Column[]{});
        }
//静态方法，它接受一个可变参数列表 excludes，用于排除一些列。
//首先，它创建了一个包含所有列的 ArrayList，通过调用 Arrays.asList(Column.values()) 来获取所有的列。
//然后，它检查传入的 excludes 是否为空且长度大于 0。如果是的话，它将传入的 excludes 列表从 columns 列表中移除。
  //最后，它将剩余的列转换为一个数组并返回。
        
        
        
        
        
        
        public String getEscapedColumnName() {
            if (this.isColumnNameDelimited) {
                return new StringBuilder().append(BEGINNING_DELIMITER).append(this.column).append(ENDING_DELIMITER).toString();
            } else {
                return this.column;
            }
        }
    }
//实例方法，用于获取列名的转义版本。
//如果 isColumnNameDelimited 为 true，它会将 column 字段用 BEGINNING_DELIMITER 和 ENDING_DELIMITER 包围起来，然后返回转义后的列名。
    //否则，它直接返回 column 字段的原始值。
  
    
    
    /*
    
    处理数据库列名的工具方法。excludes 方法允许你排除特定的列，而 getEscapedColumnName 方法用于获取转义后的列名，
    以便在SQL查询中使用。这些方法可能与某种ORM（对象-关系映射）框架或数据库操作工具一起使用，以简化数据库操作的实现。
    
    */
    
    //用于在Java应用程序中处理数据库列的框架的一部分。
}